/**  
 * RSA编码组件
 * @Title:  RSACoder.java   
 * @Package com.sdj.quick.web.util   
 * @author: chenao   
 * @date:   2018年4月18日 上午10:03:14   
 */ 
package com.sdj.quick.web.util;

import java.io.FileInputStream;
import java.security.Key;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.Signature;
import java.security.cert.Certificate;
import java.security.cert.CertificateFactory;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.HashMap;
import java.util.Map;

import javax.crypto.Cipher;

import org.apache.commons.codec.binary.Hex;

/**
 * RSA编码组件
 * @author chenao
 */
public class RSACoder {
	
	//非对称加密密钥算法
	public static final String KEY_ALGORITHM = "RSA";
	//X.509公钥标准
	public static final String X509 = "X.509";
	//数字签名，签名/验证算法
	public static final String SIGNATURE_ALGORITHM = "SHA1withRSA";
	//公钥
	private static final String PUBLIC_KEY = "RSAPublicKey";
	//私钥
	private static final String PRIVATE_KEY = "RSAPrivateKey";
	
	/**
	 * RSA密钥长度，默认1024位，长度必须是64的倍数
	 */
	private static final int KEY_SIZE = 1024;
	
	
	/**
	 * 私钥解密
	 * @author chenao   
	 * @date 2018年4月18日 上午10:22:23 
	 * @param data 待解密数据
	 * @param key 私钥
	 * @return byte[] 解密数据    
	 */
	public static byte[] decryptByPrivateKey(byte[] data, byte[] key) throws Exception{
		//取得私钥
		PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(key);
		KeyFactory keyFatory = KeyFactory.getInstance(KEY_ALGORITHM);
		//生成私钥
		PrivateKey privateKey = keyFatory.generatePrivate(pkcs8KeySpec);
		//对数据解密
		Cipher cipher = Cipher.getInstance(keyFatory.getAlgorithm());
		cipher.init(Cipher.DECRYPT_MODE, privateKey);
		return cipher.doFinal(data);
	}
	
	
	/**
	 * 公钥解密
	 * @author chenao
	 * @date 2018年4月19日 下午3:04:50 
	 * @param data 待解密数据
	 * @param key 公钥
	 * @return 解密数据
	 * @throws Exception
	 */
	public static byte[] decryptByPublicKey(byte[] data, byte[] key) throws Exception{
		//取得公钥
		X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(key);
		KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
		//生成公钥
		PublicKey publicKey = keyFactory.generatePublic(x509KeySpec);
		//对数据解密
		Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
		cipher.init(Cipher.DECRYPT_MODE, publicKey);
		return cipher.doFinal(data);
	}
	
	/**
	 * 私钥加密
	 * @author: chenao   
	 * @date:   2018年4月18日 下午3:53:30 
	 * @param: @param data 待加密的数据
	 * @param: @param key 私钥
	 * @param: @throws Exception      
	 * @return: byte[] 加密数据     
	 */
	public static byte[] encryptByPrivateKey(byte[] data, byte[] key) throws Exception{
		//取得私钥
		PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(key);
		KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
		//生成私钥
		PrivateKey privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
		//对数据加密
		Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
		cipher.init(Cipher.ENCRYPT_MODE, privateKey);
		return cipher.doFinal(data);
	}
	
	/**
	 * 公钥加密
	 * @author: chenao   
	 * @date:   2018年4月18日 下午4:08:18 
	 * @param: @param data 待加密数据
	 * @param: @param key 公钥
	 * @param: @throws Exception      
	 * @return: byte[] 加密数据     
	 */
	public static byte[] encryptByPublicKey(byte[] data, byte[] key) throws Exception{
		//取得公钥
		X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(key);
		KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
		//生成公钥
		PublicKey publicKey = keyFactory.generatePublic(x509KeySpec);
		//对数据加密啊
		Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
		cipher.init(Cipher.ENCRYPT_MODE, publicKey);
		return cipher.doFinal(data);
	}
	
	/**
	 * 初始化密钥
	 * @author: chenao   
	 * @date:   2018年4月18日 下午4:22:59 
	 * @param: @throws Exception      
	 * @return: Map<String,Object> 密钥Map      
	 */
	public static Map<String, Object> initKey() throws Exception{
		//实例化密钥对生成器
		KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);
		//初始化密钥生成器
		keyPairGen.initialize(KEY_SIZE);
		//生成密钥对
		KeyPair keyPair = keyPairGen.generateKeyPair();
		//获取公钥
		RSAPublicKey publicKey = (RSAPublicKey)keyPair.getPublic();
		//获取私钥
		RSAPrivateKey privateKey = (RSAPrivateKey)keyPair.getPrivate();
		//封装密钥
		Map<String, Object> keyMap = new HashMap<String, Object>();
		keyMap.put(PUBLIC_KEY, publicKey);
		keyMap.put(PRIVATE_KEY, privateKey);
		return keyMap;
	}
	
	/**
	 * 获取私钥
	 * @author: chenao   
	 * @date:   2018年4月18日 下午4:30:16 
	 * @param: @param keyMap 密钥Map
	 * @param: @throws Exception      
	 * @return: byte[] 私钥     
	 */
	public static byte[] getPrivateKey(Map<String, Object> keyMap) throws Exception{
		Key key = (Key)keyMap.get(PRIVATE_KEY);
		return key.getEncoded();
	}
	
	/**
	 * 获取公钥
	 * @author: chenao   
	 * @date:   2018年4月18日 下午4:32:40 
	 * @param: @param keyMap 密钥Map
	 * @param: @throws Exception      
	 * @return: byte[] 公钥     
	 */
	public static byte[] getPublicKey(Map<String, Object> keyMap) throws Exception{
		Key key = (Key)keyMap.get(PUBLIC_KEY);
		return key.getEncoded();
	}
	
	/**
	 * 私钥签名
	 * @author: chenao   
	 * @date:   2018年4月18日 下午4:38:44 
	 * @param: @param data 待签名数据
	 * @param: @param privateKey 私钥
	 * @param: @throws Exception      
	 * @return: byte[] 签名数据     
	 */
	public static byte[] sign(byte[] data, byte[] privateKey) throws Exception{
		//取得私钥
		PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(privateKey);
		KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
		//生成私钥
		PrivateKey priKey = keyFactory.generatePrivate(pkcs8KeySpec);
		//实例化签名Signature
		Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
		//初始化签名
		signature.initSign(priKey);
		//更新
		signature.update(data);
		//签名
		return signature.sign();
	}
	
	/**
	 * 公钥校验签名
	 * @author: chenao   
	 * @date:   2018年4月18日 下午4:44:32 
	 * @param: @param data 待校验数据
	 * @param: @param publicKey 公钥
	 * @param: @param sign 数字签名
	 * @param: @throws Exception      
	 * @return: boolean 检验成功返回true,失败返回false     
	 */
	public static boolean verify(byte[] data, byte[] publicKey, byte[] sign) throws Exception{
		//获取公钥
		X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(publicKey);
		KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
		//生成公钥
		PublicKey pubKey = keyFactory.generatePublic(x509KeySpec);
		//实例化签名Signature
		Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
		//初始化签名
		signature.initVerify(pubKey);
		//更新
		signature.update(data);
		//验证
		return signature.verify(sign);
	}
	
	/**
	 * 获取密钥
	 * @author: chenao   
	 * @date:   2018年4月18日 下午5:06:30 
	 * @param: @param key 密钥
	 * @param: @throws Exception      
	 * @return: byte[] 密钥     
	 */
	public static byte[] getKey(String key) throws Exception{
//		return Hex.decodeHex(key.toCharArray());
		return Base64.base64ToByteArray(key);
	}
	
	/**
	 * 私钥签名
	 * @author: chenao   
	 * @date:   2018年4月18日 下午5:08:56 
	 * @param: @param data 待签名数据
	 * @param: @param privateKey 私钥
	 * @param: @throws Exception      
	 * @return: String  十六进制签名字符串    
	 */
	public static String sign(byte[] data, String privateKey) throws Exception{
		byte[] sign = sign(data, getKey(privateKey));
//		return String.valueOf(Hex.encodeHex(sign));
		return Base64.byteArrayToBase64(sign);
	}
	
	
	/**
	 * 公钥检验签名
	 * @author: chenao   
	 * @date:   2018年4月18日 下午5:10:40 
	 * @param: @param data 待验证数据[Base64]
	 * @param: @param publicKey 公钥
	 * @param: @param sign 数字签名[Base64]
	 * @param: @throws Exception      
	 * @return: boolean 检验成功返回true,失败返回false        
	 */
	public static boolean verify(String signature, String publicKey, String sign) throws Exception{
//		return verify(data, getKey(publicKey), Hex.decodeHex(sign.toCharArray()));
		return verify(Base64.base64ToByteArray(signature), getKey(publicKey), Base64.base64ToByteArray(sign));
	}
	
	
	
	/**
	 * 私钥加密 
	 * @author: chenao   
	 * @date:   2018年4月18日 下午5:17:43 
	 * @param: @param data 待加密数据
	 * @param: @param key 私钥
	 * @param: @throws Exception      
	 * @return: byte[] 加密数据     
	 */
	public static byte[] encryptByPrivateKey(byte[] data, String key) throws Exception{
		return encryptByPrivateKey(data, getKey(key));
	}
	
	/**
	 * 私钥加密 
	 * @author: chenao   
	 * @date:   2018年4月18日 下午5:17:43 
	 * @param: @param data 待加密数据
	 * @param: @param key 私钥
	 * @param: @throws Exception      
	 * @return: String base64加密数据     
	 */
	public static String encryptByPrivateKeyToBase64(byte[] data, String key) throws Exception{
		return Base64.byteArrayToBase64(encryptByPrivateKey(data, getKey(key)));
	}
	
	/**
	 * 公钥加密
	 * @author: chenao   
	 * @date:   2018年4月18日 下午5:19:40 
	 * @param: @param data 待加密数据
	 * @param: @param key 公钥
	 * @param: @throws Exception      
	 * @return: byte[] 加密数据     
	 */
	public static byte[] encryptByPublicKey(byte[] data, String key) throws Exception{
		return encryptByPublicKey(data, getKey(key));
	}
	
	/**
	 * 公钥加密
	 * @author: chenao   
	 * @date:   2018年4月18日 下午5:19:40 
	 * @param: @param data 待加密数据
	 * @param: @param key 公钥
	 * @param: @throws Exception      
	 * @return: String base64加密数据     
	 */
	public static String encryptByPublicKeyToBase64(byte[] data, String key) throws Exception{
		return Base64.byteArrayToBase64(encryptByPublicKey(data, getKey(key)));
	}
	
	/**
	 * 私钥解密
	 * @author: chenao   
	 * @date:   2018年4月18日 下午5:21:06 
	 * @param: @param data 待解密数据[Base64]
	 * @param: @param key 私钥[Base64]
	 * @param: @throws Exception      
	 * @return: byte[] 解密数据     
	 */
	public static byte[] decryptByPrivateKey(String data, String key) throws Exception{
		return decryptByPrivateKey(Base64.base64ToByteArray(data), getKey(key));
	}
	
	
	/**
	 * 公钥解密
	 * @author: chenao   
	 * @date:   2018年4月18日 下午5:21:06 
	 * @param: @param data 待解密数据
	 * @param: @param key 公钥
	 * @param: @throws Exception      
	 * @return: byte[] 解密数据     
	 */
	public static byte[] decryptByPublicKey(byte[] data, String key) throws Exception{
		return decryptByPublicKey(data, getKey(key));
	}
	
	/**
	 * 获取私钥
	 * @author: chenao   
	 * @date:   2018年4月18日 下午5:37:17 
	 * @param: @param keyMap
	 * @param: @throws Exception      
	 * @return: String  私钥[Base64]    
	 */
	public static String getPrivateKeyString(Map<String, Object> keyMap) throws Exception{
		return Base64.byteArrayToBase64(getPrivateKey(keyMap));
//		return String.valueOf(Hex.encodeHex(getPrivateKey(keyMap)));
	}
	
	/**
	 * 初始化公钥
	 * @author: chenao   
	 * @date:   2018年4月18日 下午5:37:17 
	 * @param: @param keyMap
	 * @param: @throws Exception      
	 * @return: String      
	 */
	public static String getPublicKeyString(Map<String, Object> keyMap) throws Exception{
		return Base64.byteArrayToBase64(getPublicKey(keyMap));
//		return String.valueOf(Hex.encodeHex(getPublicKey(keyMap)));
	}
	
	/**
	 * 加载数字证书
	 * @author chenao
	 * @date 2018年4月24日 下午5:37:11 
	 * @param path 证书路径
	 * @return
	 * @throws Exception 
	 * @return
	 */
	public static Certificate getCertificate(String path) throws Exception{
		//实例化证书工厂
		CertificateFactory cf = CertificateFactory.getInstance(X509);
		//获取证书流
		FileInputStream in = new FileInputStream(path);
		//生成证书
		Certificate certificate = cf.generateCertificate(in);
		in.close();
		return certificate;
	}
	
	/**
	 * 根据证书获取公钥
	 * @author chenao
	 * @date 2018年4月24日 下午5:44:07 
	 * @param certificatePath 证书路径
	 * @return
	 * @throws Exception 
	 * @return
	 */
	public static PublicKey getPublicKey(String certificatePath) throws Exception{
		//获取证书
		Certificate certificate = getCertificate(certificatePath);
		//获取公钥
		PublicKey publicKey = certificate.getPublicKey();
		return publicKey;
	}
	
	
	public static void main(String[] args) throws Exception {
		/**
		 * 生成公私钥给平台合作方，也可以让合作方自己生成，并让其提供公钥用于服务端验证签名
		 */
		Map<String, Object> clientKeyMap = RSACoder.initKey();
		String privateKey = RSACoder.getPrivateKeyString(clientKeyMap);
		String publicKey = RSACoder.getPublicKeyString(clientKeyMap);
		
		Map<String, Object> serverKeyMap = RSACoder.initKey();
		String privateKey1 = RSACoder.getPrivateKeyString(serverKeyMap);
		String publicKey1 = RSACoder.getPublicKeyString(serverKeyMap);
		System.err.println("客户端公钥：" + publicKey);
		System.err.println("客户端私钥：" + privateKey);
		System.err.println("服务端私钥：" + privateKey1);
		System.err.println("服务端公钥：" + publicKey1);
		
		
		/**--------------- 以下模拟两对密钥(Base64格式)客户端与服务端交互  --------------------------- */
		//客户端公私钥
		String clientPublicKey = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCVjDARznw5f5WTwFfIIEhNZVLX02UOvrRwyssbp3alzrdd5ZXJHsrNE3FochzhJRl+IjVQy8bd539nLbSox+v667yAtp477LsFvXj9oqoi2R4+EnyQmuD/MtBJVAv2ceTX1/GM6s+nk8Hxe98ss/DSLlG9Q1g5Tm7blgXsAuIJSwIDAQAB";
		String clientPrivateKey = "MIICdgIBADANBgkqhkiG9w0BAQEFAASCAmAwggJcAgEAAoGBAJWMMBHOfDl/lZPAV8ggSE1lUtfTZQ6+tHDKyxundqXOt13llckeys0TcWhyHOElGX4iNVDLxt3nf2cttKjH6/rrvIC2njvsuwW9eP2iqiLZHj4SfJCa4P8y0ElUC/Zx5NfX8Yzqz6eTwfF73yyz8NIuUb1DWDlObtuWBewC4glLAgMBAAECgYAWq6TR3jqIwOWc+2iTRwmO6hBP9ZT5UkGqY6O8sntTEW5MxrQZRBi8U/k6OypTmzstGuR4NhwUobZ3nr8nYv9L0nzbqk0oDV5Do8Q7gSIiz9A+bfdT215i8cIlzid7qUtCC0kxwYagK2K+n2juPL2kxbunY63gzFdFx1TvSl6tWQJBAPnIgkmuWr+nWRu42vUmhF4kuppyIVA0vuqQ4A5+K8dmQwE1qbX9iFidxT7BqkqYz7RYSvka1QCTyf+a4+MnQF0CQQCZRQdWRCfrir7mcy/PTfj6IsLTZIxW5/jZ238C/TB0DMH4LIq6XSU8C529k+T0cJQhX/JEvpPkGqjniqHlfvXHAkBWEzqSmXq8QLb8Tp9li3hh2NZVEq9YLFT+EB6l3+TGOf8tE4kAJfYuU2/9SE+elTo+M47ieNSd9k/NvVp6lLQhAkA70sGmXjvmp+UTNep3U8vWdjLtJ9XPJgPvpMjSddivszsSjvAnBaw+35nWIR/AeSCYVkbNpkU7R1yd43KFjSSJAkEAsTYJLfD8iG0LEbTtUSSn2ACF3f2x8WDISM1xK5IGAoU53e19q6jfxu5gZzObZQKM4r+dC96V/Hbk1AOaM0AbjQ==";
		
		//服务端公私钥
		String serverPublicKey = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQC9moLfctLitKVIYoYqBD7mEiJFu4OQyKcXM0r9M0tkX4Erbe2YhV+4qXFruOR3HTPGTaudHNLCJJhlb6tg706eOYCclhlt4N2X6dzrYpe7IH28thprX7UVa1NPGIdaS09o7Eca9ze2hB582sQqAlF7hiA5jCEJ8V2D9ox1Z3tkKwIDAQAB";
		String serverPrivateKey = "MIICdwIBADANBgkqhkiG9w0BAQEFAASCAmEwggJdAgEAAoGBAL2agt9y0uK0pUhihioEPuYSIkW7g5DIpxczSv0zS2RfgStt7ZiFX7ipcWu45HcdM8ZNq50c0sIkmGVvq2DvTp45gJyWGW3g3Zfp3Otil7sgfby2GmtftRVrU08Yh1pLT2jsRxr3N7aEHnzaxCoCUXuGIDmMIQnxXYP2jHVne2QrAgMBAAECgYEAjqMpp55DRifuW9k642sUQpML03fwz0AUa+C7nmYzZoxuqVRmtSJJU6utVwPeZDnE1H9kBqtDZqiPOWhb/m2prxTU1IZ3JLEv6ormgsre63VolBDenZ7z/uqY5raZqp4zSN9CPq2zbsnwgR8sKT3X2p9nJ9j+p7S+gFLFGmrNYSkCQQDoIH7znJtxYYF1mPaKNYbIWod9Dzf6vqUGEoUWah1MErm7DvCOFik0Fzc1pTz7G5SxgTBWqwH29aDxz3AJ9g7fAkEA0RpynezaHlXDnvzzw2RuJ5FbS9YtxfVVcFRSO6TSE4DgIgFO+HNa/cY8telX8x2UAWrEpdj5Os5LuLLruc+wNQJAbvUxmgNvLkhcmLjwiGpDrjvP7hC7Qomk2n05ztgUfwuoamkexdyD/5llU6hTuPibICpPz+3Yd5M8RrpQpQJQYwJBALuZO819yq6+iTPhgx0AxGcRXNQsAoMAuTd/HwvNsn+29t7rR5tVewQEz0DxaWt/VOL0lBqrD+b3YC4Dr8LTlyUCQB516zoxm/LotMoVR3QlZSUQ5P0FAH5Aq8n5VtE6O0Ggt2iW5wxjZDS3900zaE9IZRTjTyQDLjol3Wjz6xiRizg=";
		
		Map<String, String> paramsMap = new HashMap<String, String>();
		paramsMap.put("customerNo", "861945678");
		paramsMap.put("partnerNo", "961945678");
		paramsMap.put("remark", "dododo");
		paramsMap.put("serviceType", "yumPay");
		String path = "http://192.168.57.188:8088/mobileserver/openApi/yumPay.action";
		
		/**拼装验签加密数据**/
	    String postEncryptionParams = VerifyParamtersUtils.mapToPostUrl(paramsMap);
		/**--------------- 客户端  --------------------------------------------- */
		/**
		 * 1. 原始请求数据
		 */
//		String dataStr = "customerNo=876519323&partneNo=869556236&nimeide=你妹的";
		
		/**
		 * 2. 对数据进行摘要处理（用于验证数据完整性）
		 */
		String digest = Coder.encryptSHA256(postEncryptionParams);
		
		/**
		 * 3. 服务端公钥加密数据(服务端用私钥解密数据)
		 */
		byte[] signature = RSACoder.encryptByPublicKey(digest.getBytes(), serverPublicKey);
		String signatureBase64Str = Base64.byteArrayToBase64(signature);
		
		/**
		 * 4. 客户端签名(用于抗否认性)
		 */
		String sign = RSACoder.sign(signature, clientPrivateKey);
		
		/**
		 * 5. 在实际的应用场景中，客户端会将原始数据dataStr+私钥加密signatureBase64Str+签名sign 发送给 服务端。
		 */
		paramsMap.put("signature", signatureBase64Str);
		paramsMap.put("sign", sign);
	    String resultCode = HttpClientUtil.post(path, paramsMap);
	    System.out.println(resultCode);
		
		
		
		
		/**------------------服务端------------------------------------------------*/
		
		/**
		 * 1. 服务端获取客户端请求数据:加密数据signatureBase64Str,签名sign
		 *    使用客服端公钥验证签名，校验请求是否合法
		 */
//		boolean ver = RSACoder.verify(signatureBase64Str, clientPublicKey, sign);
//		if(ver){
//			System.out.println("验证签名通过!");
//			/**
//			 * 2. 服务端私钥解密数据，获取摘要数据
//			 */
//			String clientDigest = new String(RSACoder.decryptByPrivateKey(signatureBase64Str, serverPrivateKey));
//			
//			/**
//			 * 3. 使用获取到的(请求原始数据)进行服务端encryptSHA256摘要加密，用于比较是否和第二步解密出来的数据完整一致
//			 */
//			String serverDigest = Coder.encryptSHA256(postEncryptionParams);
//			
//			/**
//			 * 4. 比较clientDigest和serverDigest是否一致，也就是解密后的数据是否和URL明文里的数据一样
//			 *    一致的话进行下一步，否则参数被修改。
//			 */
//			if(serverDigest.equals(clientDigest)){
//				/**
//				 * 5. 一致则证明是授权合作方请求，服务端获取参数后进行正常业务处理
//				 */
//				//TODO
//				System.out.println("明文参数摘要和签名密文摘要匹配，进行正常业务处理！");
//			}else{
//				/**
//				 * 6. 不一致，非法请求return
//				 */
//				System.err.println("明文参数被修改，非法请求");
//			}
//		}else{
//			/**
//			 * 不一致，非法请求return
//			 */
//			System.err.println("用户签名验证不通过!非法请求");
//		}
		
		
		
		
//		System.out.println(Coder.encryptMD5(""));
//		String request = "放假哦额忘记了房间哦的撒扔2哦";
//		String cerPath = "D://workspace//mobileserver//src//main//webapp//keystore//sdj_base64.cer";
//		PublicKey pk = RSACoder.getPublicKey(cerPath);
//		byte[] enReqeust = RSACoder.encryptByPublicKey(request.getBytes(), pk.getEncoded());
//		System.out.println(Hex.decodeHex("e5af86e992a5e695b0e68daee6b58be8af95".toCharArray()));
	}
	
}
